// @/src/stores/shop.js
import { defineStore } from 'pinia';
import { ref } from 'vue';
import { useUserStore } from './user'; // 引入user store，用于获取用户ID
import {
    addItemToCartAPI,
    listCartItemsAPI,
    updateCartItemQuantityAPI,
    removeCartItemAPI,
    removeCartItemsBatchAPI,
    clearCartAPI,
    getCartItemCountAPI
} from '@/api/ShopApi'; // 引入新创建的购物车API

export const useShopStore = defineStore('shop', () => {
    // 购物车相关的响应式状态
    const cartItems = ref([]); // 存储购物车中商品项的列表，每个项是一个CartDTO对象
    const cartItemCount = ref(0); // 存储购物车中不同商品的总种类数

    // 数据同步状态管理
    const isDataDirty = ref(false); // 标记数据是否已变更，需要同步
    const lastSyncTime = ref(0); // 最后同步时间戳
    const syncCooldown = 5 * 60 * 1000; // 同步冷却时间：5分钟

    // 访问用户store以获取当前用户ID
    const userStore = useUserStore();

    /**
     * 辅助函数：获取当前用户ID
     * @returns {Long|null} 当前用户ID，如果未登录则返回null
     */
    const getCurrentUserId = () => {
        return userStore.userInfo?.userId || null;
    };

    /**
     * 获取本地存储的购物车数据键名
     * @returns {string} 本地存储键名
     */
    const getCartStorageKey = () => {
        const userId = getCurrentUserId();
        return userId ? `cart_${userId}` : 'cart_guest';
    };

    /**
     * 保存购物车数据到本地存储
     */
    const saveCartToLocalStorage = () => {
        try {
            const storageKey = getCartStorageKey();
            const cartData = {
                items: cartItems.value,
                count: cartItemCount.value,
                timestamp: Date.now()
            };
            localStorage.setItem(storageKey, JSON.stringify(cartData));
        } catch (error) {
            console.error('保存购物车到本地存储失败:', error);
        }
    };

    /**
     * 从本地存储加载购物车数据
     */
    const loadCartFromLocalStorage = () => {
        try {
            const storageKey = getCartStorageKey();
            const storedData = localStorage.getItem(storageKey);

            if (storedData) {
                const cartData = JSON.parse(storedData);
                // 检查数据是否过期（24小时）
                const isExpired = Date.now() - cartData.timestamp > 24 * 60 * 60 * 1000;

                if (!isExpired) {
                    cartItems.value = cartData.items || [];
                    cartItemCount.value = cartData.count || 0;
                    return true;
                } else {
                    // 数据过期，清除本地存储
                    localStorage.removeItem(storageKey);
                }
            }
        } catch (error) {
            console.error('从本地存储加载购物车数据失败:', error);
        }
        return false;
    };

    /**
     * 清除本地存储的购物车数据
     */
    const clearLocalCartStorage = () => {
        try {
            const storageKey = getCartStorageKey();
            localStorage.removeItem(storageKey);
        } catch (error) {
            console.error('清除本地购物车存储失败:', error);
        }
    };

    /**
     * 标记数据为已变更，需要同步
     */
    const markDataDirty = () => {
        isDataDirty.value = true;
        console.log('🔄 数据已标记为需要同步');
    };

    /**
     * 检查是否需要同步数据
     * @returns {boolean} 是否需要同步
     */
    const shouldSyncData = () => {
        const now = Date.now();
        const timeSinceLastSync = now - lastSyncTime.value;

        // 如果数据已变更 且 距离上次同步超过冷却时间
        return isDataDirty.value && timeSinceLastSync > syncCooldown;
    };

    /**
     * 智能同步数据 - 只在必要时从服务器获取
     */
    const smartSync = async () => {
        if (!shouldSyncData()) {
            console.log('📦 使用本地缓存，无需同步');
            return false; // 无需同步
        }

        console.log('🌐 执行智能同步...');
        try {
            await fetchCartItems(true); // 强制从服务器获取
            isDataDirty.value = false;
            lastSyncTime.value = Date.now();
            console.log('✅ 数据同步完成');
            return true; // 同步成功
        } catch (error) {
            console.error('❌ 数据同步失败:', error);
            return false; // 同步失败
        }
    };

    /**
     * 将商品添加到购物车或更新其数量。
     * @param {Long} productId - 要添加的商品ID。
     * @param {Integer} quantity - 要添加/设置的数量。
     * @returns {Promise<Object|null>} 如果成功，返回更新后的CartDTO对象；否则返回null。
     */
    const addItemToCart = async (productId, quantity) => {
        const userId = getCurrentUserId();
        if (!userId) {
            throw new Error('用户未登录，请先登录。');
        }
        try {
            const res = await addItemToCartAPI(userId, productId, quantity);
            if (res.data.code === 1) {
                // 数据变更操作：立即从服务器获取最新数据并标记为需要同步
                await fetchCartItems(true);
                markDataDirty(); // 标记数据已变更
                lastSyncTime.value = Date.now(); // 更新同步时间
                return res.data.data;
            } else {
                throw new Error(res.data.msg || '添加商品到购物车失败。');
            }
        } catch (error) {
            console.error('Shop store addItemToCart error:', error);
            const errorMessage = error.response?.data?.msg || error.message || '添加商品到购物车失败，请稍后再试。';
            throw new Error(errorMessage);
        }
    };

    /**
     * 获取用户购物车中的所有商品项。
     * 优先从本地存储加载，如果本地没有数据或数据过期，则从服务器获取。
     */
    const fetchCartItems = async (forceRefresh = false) => {
        const userId = getCurrentUserId();
        if (!userId) {
            cartItems.value = [];
            cartItemCount.value = 0;
            return;
        }

        // 如果不是强制刷新，先尝试从本地存储加载
        if (!forceRefresh && loadCartFromLocalStorage()) {
            console.log('从本地存储加载购物车数据');
            return;
        }

        try {
            const res = await listCartItemsAPI(userId);
            if (res.data.code === 1) {
                cartItems.value = res.data.data || [];
                cartItemCount.value = cartItems.value.length;
                // 保存到本地存储
                saveCartToLocalStorage();
            } else {
                throw new Error(res.data.msg || '获取购物车列表失败。');
            }
        } catch (error) {
            console.error('Shop store fetchCartItems error:', error);
            const errorMessage = error.response?.data?.msg || error.message || '获取购物车列表失败，请稍后再试。';
            cartItems.value = [];
            cartItemCount.value = 0;
            throw new Error(errorMessage);
        }
    };

    /**
     * 更新购物车中特定商品的数量。
     * @param {Long} cartId - 要更新的购物车项ID。
     * @param {Integer} quantity - 商品的新数量。
     * @returns {Promise<boolean>} 成功返回true，失败返回false。
     */
    const updateCartItemQuantity = async (cartId, quantity) => {
        try {
            const res = await updateCartItemQuantityAPI(cartId, quantity);
            if (res.data.code === 1) {
                // 乐观更新：在本地状态中直接更新数量
                const index = cartItems.value.findIndex(item => item.cartId === cartId);
                if (index !== -1) {
                    cartItems.value[index].quantity = quantity;
                    // 更新本地存储
                    saveCartToLocalStorage();
                    // 标记数据已变更
                    markDataDirty();
                }
                return true;
            } else {
                throw new Error(res.data.msg || '更新购物车商品数量失败。');
            }
        } catch (error) {
            console.error('Shop store updateCartItemQuantity error:', error);
            const errorMessage = error.response?.data?.msg || error.message || '更新购物车商品数量失败，请稍后再试。';
            throw new Error(errorMessage);
        }
    };

    /**
     * 从购物车中移除单个商品。
     * @param {Long} cartId - 要移除的购物车项ID。
     * @returns {Promise<boolean>} 成功返回true，失败返回false。
     */
    const removeCartItem = async (cartId) => {
        try {
            const res = await removeCartItemAPI(cartId);
            if (res.data.code === 1) {
                // 过滤掉已移除的商品
                cartItems.value = cartItems.value.filter(item => item.cartId !== cartId);
                cartItemCount.value = cartItems.value.length;
                // 更新本地存储
                saveCartToLocalStorage();
                // 标记数据已变更
                markDataDirty();
                return true;
            } else {
                throw new Error(res.data.msg || '从购物车移除商品失败。');
            }
        } catch (error) {
            console.error('Shop store removeCartItem error:', error);
            const errorMessage = error.response?.data?.msg || error.message || '从购物车移除商品失败，请稍后再试。';
            throw new Error(errorMessage);
        }
    };

    /**
     * 批量从购物车中移除多个商品。
     * @param {Array<Long>} cartIds - 要移除的购物车项ID列表。
     * @returns {Promise<boolean>} 如果全部或部分成功返回true，如果所有都失败返回false。
     */
    const removeCartItemsBatch = async (cartIds) => {
        if (!cartIds || cartIds.length === 0) {
            throw new Error('请提供要移除的购物车ID列表。');
        }
        try {
            const res = await removeCartItemsBatchAPI(cartIds);
            if (res.data.code === 1) {
                // 批量删除后，重新从后端获取购物车列表
                await fetchCartItems(true); // 强制刷新
                markDataDirty(); // 标记数据已变更
                lastSyncTime.value = Date.now(); // 更新同步时间
                return true;
            } else {
                throw new Error(res.data.msg || '批量移除购物车商品失败或部分成功。');
            }
        } catch (error) {
            console.error('Shop store removeCartItemsBatch error:', error);
            const errorMessage = error.response?.data?.msg || error.message || '批量移除购物车商品失败，请稍后再试。';
            throw new Error(errorMessage);
        }
    };

    /**
     * 清空用户购物车中的所有商品。
     * @returns {Promise<boolean>} 成功返回true，失败返回false。
     */
    const clearCart = async () => {
        const userId = getCurrentUserId();
        if (!userId) {
            throw new Error('用户未登录，请先登录。');
        }
        try {
            const res = await clearCartAPI(userId);
            if (res.data.code === 1) {
                cartItems.value = [];
                cartItemCount.value = 0;
                // 清除本地存储
                clearLocalCartStorage();
                // 标记数据已变更
                markDataDirty();
                lastSyncTime.value = Date.now(); // 更新同步时间
                return true;
            } else {
                throw new Error(res.data.msg || '清空购物车失败。');
            }
        } catch (error) {
            console.error('Shop store clearCart error:', error);
            const errorMessage = error.response?.data?.msg || error.message || '清空购物车失败，请稍后再试。';
            throw new Error(errorMessage);
        }
    };

    /**
     * 获取用户购物车中的商品项总数（不是商品总数量）。
     * @returns {Promise<Integer>} 购物车中不同商品的种类数量。
     */
    const fetchCartItemCount = async () => {
        const userId = getCurrentUserId();
        if (!userId) {
            cartItemCount.value = 0;
            return 0;
        }
        try {
            const res = await getCartItemCountAPI(userId);
            if (res.data.code === 1) {
                cartItemCount.value = res.data.data || 0;
                return cartItemCount.value;
            } else {
                throw new Error(res.data.msg || '获取购物车商品种类数量失败。');
            }
        } catch (error) {
            console.error('Shop store fetchCartItemCount error:', error);
            const errorMessage = error.response?.data?.msg || error.message || '获取购物车商品种类数量失败，请稍后再试。';
            cartItemCount.value = 0;
            throw new Error(errorMessage);
        }
    };

    /**
     * 初始化购物车数据
     * 在应用启动时调用，优先从本地存储加载
     */
    const initializeCart = async (forceRefresh = false) => {
        const userId = getCurrentUserId();
        if (!userId) {
            cartItems.value = [];
            cartItemCount.value = 0;
            isDataDirty.value = false;
            return;
        }

        // 如果强制刷新，直接从服务器获取
        if (forceRefresh) {
            await fetchCartItems(true);
            isDataDirty.value = false;
            lastSyncTime.value = Date.now();
            return;
        }

        // 先尝试从本地存储加载
        if (loadCartFromLocalStorage()) {
            console.log('📦 从本地存储初始化购物车数据');
            // 执行智能同步检查
            await smartSync();
        } else {
            // 本地没有数据，从服务器获取
            console.log('🌐 本地无数据，从服务器初始化');
            await fetchCartItems(true);
            isDataDirty.value = false;
            lastSyncTime.value = Date.now();
        }
    };

    /**
     * 智能刷新购物车数据 - 只在必要时从服务器获取
     */
    const smartRefreshCart = async () => {
        // 优先使用本地缓存，只在数据变更时同步
        if (cartItems.value.length === 0) {
            // 如果本地没有数据，尝试从存储加载
            if (!loadCartFromLocalStorage()) {
                // 本地存储也没有，从服务器获取
                await fetchCartItems(true);
                lastSyncTime.value = Date.now();
            }
        }

        // 执行智能同步
        await smartSync();
    };

    // 返回购物车状态和方法，供组件使用
    return {
        cartItems,
        cartItemCount,
        isDataDirty, // 暴露数据变更状态
        addItemToCart,
        fetchCartItems,
        updateCartItemQuantity,
        removeCartItem,
        removeCartItemsBatch,
        clearCart,
        fetchCartItemCount,
        initializeCart,
        smartRefreshCart, // 智能刷新方法
        markDataDirty,
        smartSync,
        saveCartToLocalStorage,
        loadCartFromLocalStorage,
        clearLocalCartStorage
    };
});